home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2001 / MacHack 2001.toast / pc / The Hacks / HFS- / SerialFSServ / GenericSerial.c < prev    next >
Encoding:
Text File  |  2001-06-23  |  7.3 KB  |  375 lines
  1. // GenericSerial.c
  2. // Used on Mac & Palm platforms, for both the server/client apps
  3.  
  4. #include "GenericSerial.h"
  5.  
  6. #ifndef NULL
  7.     #define NULL (0L)
  8. #endif
  9.  
  10. static MyPacket    gInPacket;
  11.  
  12. static char        gInBuf[kMaxExtraDataSize];
  13. static char        gOutBuf[sizeof(MyPacket) + kMaxExtraDataSize];
  14.  
  15.  
  16. static void Reply(long p1, long p2, long p3, long p4, short dataSize, short result);
  17.  
  18. static void Send(short op, long p1, long p2, long p3, long p4, short dataSize, char* bufP);
  19. static void Receive(long *p1, long *p2, long *p3, long *p4, short *resultP, char *bufP);
  20.  
  21.  
  22. // called repeatedly by main event loop of server application
  23. void ServeSomething(void)
  24. {
  25.     short err;
  26.     long filep;
  27.     long numBytes, size, iterator;
  28.     // request a message:
  29.     err = SerialRead(sizeof(MyPacket), (char*)&gInPacket);
  30.     if(err != 0) return; // (0 = noErr = errNone :-)
  31.     
  32.     // check the cookie so we know we're interpreting the data correctly
  33.     if(gInPacket.cookie != kCookieValue) return;
  34.     if(gInPacket.dataSize > kMaxExtraDataSize) return;
  35.     
  36.     if(gInPacket.dataSize > 0)
  37.     {
  38.         if(gInPacket.dataSize > kMaxExtraDataSize) return;
  39.         
  40.         err = SerialRead(gInPacket.dataSize, gInBuf);
  41.         if(err != 0) return; // (0 = noErr = errNone :-)
  42.     }
  43.     
  44.     
  45.     switch(gInPacket.op)
  46.     {
  47.         case kDirEnumerate:
  48.             // param1 - dirp
  49.             // param2 - iterator
  50.             
  51.             err = LocalDirIterate(gInPacket.param1, &gInPacket.param2, gOutBuf, &size);
  52.             
  53.             // reply:
  54.             // param1 - new iterator
  55.             // result - result code
  56.             // extra data - file name, etc...
  57.             Reply(iterator, 0, 0, 0, size, err);
  58.             
  59.             break;
  60.         
  61.         case kFileOpen:
  62.             // param1 - permissions
  63.             // extra data - pathname
  64.             
  65.             // make sure we have a path:
  66.             if(gInPacket.dataSize == 0) Reply(0,0,0,0,0,-1);
  67.             err = LocalFileOpen(gInBuf, gInPacket.param1, &filep);
  68.             
  69.             // reply:
  70.             // param1 - file ptr
  71.             // result - result code
  72.             Reply(filep, 0, 0, 0, 0, err);
  73.             
  74.             break;
  75.         
  76.         case kFileClose:
  77.             // param1 - filep
  78.             
  79.             err = LocalFileClose(gInPacket.param1);
  80.             
  81.             // reply:
  82.             // result - result code
  83.             Reply(0, 0, 0, 0, 0, err);
  84.             
  85.             break;
  86.         
  87.         case kFileRead:
  88.             // param1 - filep
  89.             // param2 - numBytes
  90.             
  91.             numBytes = gInPacket.param2;
  92.             
  93.             if(numBytes > kMaxExtraDataSize) Reply(0,0,0,0,0,-1);
  94.             
  95.             // read the data...
  96.             err = LocalFileRead(gInPacket.param1, numBytes, &numBytes, gOutBuf);
  97.             
  98.             // send the data back...
  99.             // reply:
  100.             // param1 - number of bytes read (in this message)
  101.             // result - possibly error code
  102.             Reply(numBytes, 0, 0, 0, numBytes, err);
  103.                         
  104.             break;
  105.         
  106.         case kFileWrite:
  107.             // param1 - filep
  108.             // param2 - numBytes
  109.             // extra data - data to write
  110.             
  111.             numBytes = gInPacket.param2;
  112.             
  113.             // sanity check:
  114.             if(numBytes != gInPacket.dataSize) Reply(0,0,0,0,0,-1);
  115.             
  116.             // write the data...
  117.             err = LocalFileWrite(gInPacket.param1, numBytes, &numBytes, gInBuf);
  118.             
  119.             // send the reply back...
  120.             // reply:
  121.             // param1 - number of bytes read (in this message)
  122.             // result - possibly error code
  123.             Reply(numBytes, 0, 0, 0, 0, err);
  124.                         
  125.             break;
  126.         
  127.         case kFileSeek:
  128.             // param1 - filep
  129.             // param2 - origin
  130.             // param3 - offset
  131.             
  132.             err = LocalFileSeek(gInPacket.param1, gInPacket.param2, gInPacket.param3);
  133.             
  134.             // reply:
  135.             // result - result code
  136.             Reply(0, 0, 0, 0, 0, err);
  137.             
  138.             break;
  139.         
  140.         case kFileSize:
  141.             // param1 - filep
  142.             
  143.             err = LocalFileSize(gInPacket.param1, &size);
  144.             
  145.             // reply:
  146.             // p1 - size of file
  147.             // result - result code
  148.             Reply(size, 0, 0, 0, 0, err);
  149.             
  150.             break;
  151.         
  152.         case kFileRename:
  153.             // unimplemented
  154.             DebugErr("rename unimplemented");
  155.             break;
  156.         
  157.         case kFileDelete:
  158.             
  159.             break;
  160.         
  161.     }
  162.     
  163.     
  164.     return;
  165. }
  166.  
  167. // send a reply to client:
  168. void Reply(long p1, long p2, long p3, long p4, short dataSize, short result) 
  169. {
  170.     MyPacket    outPacket;
  171.     short        err;
  172.     
  173.     // initialize outPacket:
  174.     outPacket.cookie = kCookieValue;
  175.     outPacket.op = kFileOpResult;
  176.     outPacket.dataSize = dataSize;
  177.     outPacket.result = result;
  178.     outPacket.reserved = 0;
  179.     outPacket.param1 = p1;
  180.     outPacket.param2 = p2;
  181.     outPacket.param3 = p3;
  182.     outPacket.param4 = p4;
  183.     
  184.     err = SerialWrite(sizeof(MyPacket), (char*)&outPacket);
  185.     
  186.     if(err == 0 && dataSize > 0)
  187.     {
  188.         // send extra data, if any:
  189.         err = SerialWrite(dataSize, gOutBuf);
  190.     }
  191.     
  192.     return;
  193. }
  194.  
  195. void Send(short op, long p1, long p2, long p3, long p4, short dataSize, char* bufP) 
  196. {
  197.     MyPacket    outPacket;
  198.     short        err;
  199.     
  200.     if(bufP == 0) bufP = gOutBuf;
  201.     
  202.     // initialize outPacket:
  203.     outPacket.cookie = kCookieValue;
  204.     outPacket.op = op;
  205.     outPacket.dataSize = dataSize;
  206.     outPacket.result = 0;
  207.     outPacket.reserved = 0;
  208.     outPacket.param1 = p1;
  209.     outPacket.param2 = p2;
  210.     outPacket.param3 = p3;
  211.     outPacket.param4 = p4;
  212.     
  213.     err = SerialWrite(sizeof(MyPacket), (char*)&outPacket);
  214.     
  215.     if(err == 0 && dataSize > 0)
  216.     {
  217.         // send extra data, if any:
  218.         err = SerialWrite(dataSize, bufP);
  219.     }
  220.     
  221.     return;
  222. }
  223.  
  224.  
  225. void Receive(long *p1, long *p2, long *p3, long *p4, short *resultP, char *bufP)
  226. {
  227.     short err = SerialRead(sizeof(MyPacket), (char*)&gInPacket);
  228.     if(err != 0) return; // (0 = noErr = errNone :-)
  229.     
  230.     // check the cookie so we know we're interpreting the data correctly
  231.     if(gInPacket.cookie != kCookieValue) return;
  232.     if(gInPacket.dataSize > kMaxExtraDataSize) return;
  233.     
  234.     if(p1) *p1 = gInPacket.param1;
  235.     if(p2) *p2 = gInPacket.param2;
  236.     if(p3) *p3 = gInPacket.param3;
  237.     if(p4) *p4 = gInPacket.param4;
  238.     if(resultP) *resultP = gInPacket.result;
  239.     if(bufP == 0) bufP = gInBuf;
  240.     
  241.     if(gInPacket.dataSize > 0)
  242.     {
  243.         if(gInPacket.dataSize > kMaxExtraDataSize) return;
  244.         
  245.         err = SerialRead(gInPacket.dataSize, bufP);
  246.         if(err != 0) return; // (0 = noErr = errNone :-)
  247.     }
  248.     
  249. }
  250.  
  251. short RemoteFileRead(long filep, long numBytes, long *numBytesRead, char *bufP)
  252. {
  253.     short result;
  254.     long tempRead;
  255.     
  256.     result = 0; // (0 == noErr == errNone)
  257.     *numBytesRead = 0;
  258.     
  259.     while(numBytes > 0 && result == 0)
  260.     {
  261.         tempRead = numBytes;
  262.         if(tempRead > kMaxExtraDataSize) tempRead = kMaxExtraDataSize;
  263.         
  264.         // Send request & receive reply:
  265.         Send(kFileRead, filep, tempRead, 0, 0, 0, NULL);
  266.         Receive(&tempRead, NULL, NULL, NULL, &result, bufP);
  267.         
  268.         // we got tempRead bytes...
  269.         bufP += tempRead;
  270.         numBytes -= tempRead;
  271.         *numBytesRead += tempRead;
  272.         
  273.     }
  274.     
  275.     return result;
  276. }
  277.  
  278.  
  279. short RemoteFileWrite(long filep, long numBytes, long *numWritten, char *bufP)
  280. {
  281.     short result;
  282.     long tempWrit;
  283.     
  284.     result = 0; // (0 == noErr == errNone)
  285.     *numWritten = 0;
  286.     
  287.     while(numBytes > 0 && result == 0)
  288.     {
  289.         tempWrit = numBytes;
  290.         if(tempWrit > kMaxExtraDataSize) tempWrit = kMaxExtraDataSize;
  291.         
  292.         // Send request & receive reply:
  293.         Send(kFileWrite, filep, tempWrit, 0, 0, 0, bufP);
  294.         Receive(&tempWrit, NULL, NULL, NULL, &result, NULL);
  295.         
  296.         // we write tempWrit bytes...
  297.         bufP += tempWrit;
  298.         numBytes -= tempWrit;
  299.         *numWritten += tempWrit;
  300.         
  301.     }
  302.     
  303.     return result;
  304. }
  305.  
  306.  
  307.  
  308. short RemoteFileOpen(char *path, long perm, long *filePP)
  309. {
  310.     short result;
  311.     
  312.     Send(kFileOpen, perm, 0, 0, 0, StrLen(path)+1, path);
  313.     Receive(filePP, 0, 0, 0, &result, NULL);
  314.     
  315.     return result;
  316. }
  317.  
  318. short RemoteFileClose(long filep)
  319. {
  320.     short result;
  321.     
  322.     Send(kFileClose, filep, 0, 0, 0, 0, NULL);
  323.     Receive(0, 0, 0, 0, &result, NULL);
  324.     
  325.     return result;
  326. }
  327.  
  328. short RemoteFileSeek(long filep, short origin, unsigned short offset)
  329. {
  330.     short result;
  331.     
  332.     Send(kFileSeek, filep, origin, offset, 0, 0, NULL);
  333.     Receive(0, 0, 0, 0, &result, NULL);
  334.     
  335.     return result;
  336. }
  337.  
  338.  
  339. short RemoteFileSize(long filep, long *size)
  340. {
  341.     short result;
  342.     
  343.     Send(kFileSize, filep, 0, 0, 0, 0, NULL);
  344.     Receive(size, 0, 0, 0, &result, NULL);
  345.     
  346.     return result;
  347. }
  348.  
  349.  
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363.  
  364.  
  365.  
  366.  
  367.  
  368.  
  369.  
  370.  
  371.  
  372.  
  373.  
  374.  
  375.